/******************************
 * @作用 管理XML数据
 * @创建人 李志勇 
 * @创建日期 2011-10-22
 *****************************/
#ifndef __BASE__XMLDATAMANAGER_H
#define __BASE__XMLDATAMANAGER_H

#include "Common.h"
#include "Singleton.h"
#include "String.h"
#include "tinyxml/tinyxml.h"
#include "GameDefine.h"

// 财富称号
struct WealthTitle
{
	uint32 wealth; // 财富
	String desc; // 描述
	WealthTitle():wealth(0),desc(""){}
};
// 新手房间奖励
struct JackerooHortation
{
	uint32 condition; // 发放礼包的条件
	std::vector<uint32> vecGift; // 礼包
	JackerooHortation():condition(0){}
	void AddGift(const uint32 gift){vecGift.push_back(gift);}
	void Clear(){vecGift.clear();}
	const uint32 GetGift() const
	{
		if (0 == vecGift.size())
			return 0;
		int index = rand() % vecGift.size();
		return vecGift[index];
	}
};
// 通用麻将任务
struct MaJonMission
{
	uint32 model_id;	//任务模式号
	uint32 type;		//任务难度（1 低级 2 中级 3 高级）
	uint32 fan_num;		//任务番数
	uint32 coins;		//任务奖励铜钱
	uint32 hongbao;		//任务奖励红包
	uint8 status;		//任务状态（1 进心中 2 任务完成）
	
	String sName;		//任务名称
	String sBounty;		//任务奖励
	String sDesc;		//任务悬浮描述
	
	MaJonMission()
	{
		init();
	}
	
	void init()
	{
		model_id = 0;
		type = 0;
		fan_num = 0;
		coins = 0;
		hongbao = 0;
		status = 1;
		
		sName = "";
		sBounty = "";
	}
};

// 连续登录奖励
struct LoginGift
{
	uint32 days;
	uint32 modelId;
	uint32 number;
};
//黄钻等级奖励
struct WebLvBounty
{
	uint32 level;
	uint32 money;
	uint32 match;
	uint32 change;
	uint32 jb;
	WebLvBounty(void):level(0),money(0),match(0),change(0),jb(0){}
};
// 机率项结构
typedef struct __chance_item_st_
{
	uint8 id;
	uint32 chance;
	uint32 type;
	uint32 model_id;
	uint32 num;
	uint32 num2;
	uint32 max_emerge;
	uint32 curr_emerge;
	String desc;
	
	__chance_item_st_(void):chance(0),type(0),model_id(0),num(0),num2(0),max_emerge(0),curr_emerge(0){}
}ChanceItem;

// 机率结构
typedef struct _item_chance_list_st_
{
	std::list<ChanceItem> items;
	uint32 kind_id;
	
}ChanceList;

// IP信息
struct ServerIP
{
	uint16 	id;
	uint16  port;
	String  ip;
	ServerIP(void):id(0),port(0),ip(""){}
};
// 邮件模板
struct MailModel
{
	String szTitle;
	String szContent;
	MailModel(void):szTitle(""),szContent(""){}
};
// 金银转盘配置
struct BuyLargess
{
	uint32 buy;
	uint32 largess;
	uint32 number;
	uint32 exp;
};

// 分区信息
struct GZIDInfo
{
	uint32 gzId;
	uint32 maxSize;	// 最新版本的大小
	String minVersion;	// 最低版本号
	String maxVersion;	// 最新版本号
	String maxAddr;	// 最新版本的地址
};

// 赠送打折卡结构
struct LeCardGive
{
	uint32 days;
	uint32 num;
	uint32 type;
	
	LeCardGive(void):days(0),num(0),type(0){}
};

struct FruitBounty
{
	uint32 chance_id;	//中奖序列号
	uint32 chance;		//中奖几率
	uint32 bounty_id;	//中奖序号
	uint8 big;			//水果大小
	uint32 multiple;	//中奖倍数
	uint8 exist;	//最大出现次数
	
	FruitBounty(void)
	{
		chance_id = 0;
		chance = 0;
		bounty_id = 0;
		big = 0;
		multiple = 0;
		exist = 0;
	};
};
// 开心牧场牲畜结构
struct HappyFarm
{
	uint32 model_id;
	uint32 price;
	uint32 feeding_cycle;
	uint32 earnings;
	uint32 need_vip;
	String szName;
	void Init()
	{
		model_id = 0;
		price = 0;
		feeding_cycle = 0;
		earnings = 0;
		need_vip = 0;
		szName = "";
	}
	HappyFarm()
	{
		Init();
	}
};

// 排行配置数据机构
struct stOrderInfo
{
	String strKey;					// 字符串键值
	uint32 order_type;				// 排行数字类型
	String orderValu_key;			// 排行用于排序的主字段
	String orderValu_key2;			// 排行用于排序的次字段
	uint32 maxPlayerNum;			// 排行最大人数
	uint32 reset_mode;				// 排行重置周期（1 时， 2 天， 3 周，4 月） 0 表示默认
	uint32 reset_data;				// 排行重置数值（重置周期的具体数值）
	uint32 update_mode;				// 排行更新周期（1 时， 2 天， 3 周，4 月） 0 表示默认
	uint32 update_data;				// 排行更新数值（更新周期的具体数值）
	std::vector<uint32> vGzids;		// 以分区进行排行
	std::vector<uint32> vAgents;	// 以代理商进行排行
	
	uint32 data_gzid;				// 数据分区ID
	uint32 last_resetTimer;			// 上一次重置数据时间
	
	stOrderInfo()
	{
		init();
	}
	
	void init()
	{
		strKey = "";
		order_type = 0;
		orderValu_key = "";
		orderValu_key2 = "";
		maxPlayerNum = 0;
		
		reset_mode = 0;
		reset_data = 0;
		update_mode = 0;
		update_data = 0;
		
		vGzids.clear();
		vAgents.clear();
		
		data_gzid = 0;
		last_resetTimer = 0;
	}
};

// 组局开局费配置
struct stCenterBattleOpenCoins
{
	uint32 model_id;
	uint32 num;				// 房主付费数量
	uint32 aa_num;			// AA制付费数量
	uint32 loop;			// 限制数值
	uint8 mode;				// 游戏模式
	uint32 time;			// 1 轮数限制 2 时间限制
	uint32 min;				// 最小局数
	uint32 watch;			// 观战
	
	uint32 free_mode;					// 费用模式
	uint32 free_begin_time;				// 免费开始时间
	uint32 free_end_time;				// 免费结束时间
	
	uint32 cycle_weekday_begin;			// 每周起始周几
	uint32 cycle_weekday_end;			// 每周结束周几
	
	uint32 cycle_weekdayhour_begin;		// 每周起始小时
	uint32 cycle_weekdayhour_end;		// 每周结束小时
	
	uint32 cycle_weekdayminiute_begin;	// 每周起始分钟
	uint32 cycle_weekdayminiute_end;	// 每周结束分钟
	
	uint32 join_point_lsestMult;		// 金币场，加入最低不能低于底分的倍数
	uint32 exit_point_lsestMult;		// 金币场，离开最低不能低于底分的倍数
	
	uint32 force_time;					// 强制开局时间（时间到牌桌强制解散）
	float fDjPercent;					// 对局费扣除比例
	uint8 nCloseOwnerRecord;			// 是否关闭房主添加日志（当房主创建后没有进行游戏的时候）
	bool bCheckSameIp;					// 检测同IP玩家是否可以进入（0 不检测 1 检测）
	uint8 gamestart_join;				// 游戏开始是否可进入（0 不可 1 可以）
	uint32 unready_kick_count;			// 未准备次数超限被踢
	uint32 idel_kick_timer;				// 一直不准备，空闲被踢等待时间
	uint32 tuoguan_kick_count;			// 托管次数超限
	uint32 use_club_diamand;			// 是否使用俱乐部钻石
	
	std::vector<String> vPfs;			// 玩法支持的平台列表
	String desc;						// 玩法描述
	
	stCenterBattleOpenCoins()
	{
		Init();
	}
	
	void Init()
	{
		model_id = 0;
		num = 0;
		aa_num = 0;
		loop = 0;
		mode = 0;
		time = 0;
		min = 0;
		watch = 0;
		
		free_mode = 0;
		free_begin_time = 0;
		free_end_time = 0;
		
		cycle_weekday_begin = 0;
		cycle_weekday_end = 0;
		
		cycle_weekdayhour_begin = 0;
		cycle_weekdayhour_end = 0;
		
		cycle_weekdayminiute_begin = 0;
		cycle_weekdayminiute_end = 0;
		
		join_point_lsestMult = 0;
		exit_point_lsestMult = 0;
		
		force_time = 0;
		fDjPercent = 0.0f;
		nCloseOwnerRecord = 0;
		bCheckSameIp = false;
		gamestart_join = 1;
		unready_kick_count = 0;
		idel_kick_timer = 0;
		tuoguan_kick_count = 0;
		use_club_diamand = 0;
		
		vPfs.clear();
		desc = "";
	}
	
};

struct stCenterBattleMode
{
	uint32 game_id;
	uint32 town_id;
	uint32 ai;
	uint32 mode;
	
	stCenterBattleMode()
	{
		Init();
	}
	
	void Init()
	{
		game_id = 0;
		town_id = 0;
		ai = 0;
		mode = 0;
	}
	
};

struct stBuyUnionGoods
{
	uint32 id;		// 商品ID
	uint32 type;	// 商品类型（1 打包）
	
	String name;	// 商品名称
	String items;	// 道具json
	
	stBuyUnionGoods()
	{
		Init();
	}
	
	void Init()
	{
		id = 0;
		type = 0;
		
		name = "";
		items = "";
	}
	
};

// 通用单个在线奖励
struct stCommonSingleGift
{
	uint32 id;		// 奖励ID
	uint32 seconds;	// 需要的在线时长（秒）
	uint32 coins;	// 可获得的铜钱数量
	
	stCommonSingleGift()
	{
		Init();
	}
	
	void Init()
	{
		id = 0;
		seconds = 0;
		coins = 0;
	}
};

// 通用在线奖励
struct stCommonOnlineGift
{
	uint8 isDaily;			// 是否每日刷新（0 否 1 是）
	uint8 isSameTime;		// 是否同时计时（0 否 1 是）
	String strOnlineKey;	// 在线奖励对应角色user_data键
	
	std::map<uint32, stCommonSingleGift> mapGift;	// 奖励列表
	
	stCommonOnlineGift()
	{
		Init();
	}
	
	void Init()
	{
		isDaily = 0;
		isSameTime = 0;
		strOnlineKey = "";
		
		mapGift.clear();
	}
};

// 游戏玩法名称
struct stGameModelName
{
	uint32 game_id;
	uint32 model_id;
	
	String name;
	
	stGameModelName()
	{
		game_id = 0;
		model_id = 0;
		name = "";	
	}
};

//淘汰积分增长
struct stEliminateIncrease
{
	uint32 eliminate;			//淘汰分数
	uint32 base;				//底分
	uint32 timeUp;				//增长时间 秒
	stEliminateIncrease() {
		init();
	}
	void init() {
		eliminate = 0;
		base = 0;
		timeUp = 0;
	}
};

enum enEndConditionType
{
	enEndConditionType_battleNum = 1,			//游戏局数
	enEndConditionType_playerNum = 2,			//剩余玩家人数

};

//打立出局结束条件
struct stEndCondition
{
	uint32 min;			//最少人数
	uint32 max;			//最多人数
	uint8  endType;		//结束标准
	uint16 endNumber;	//结束数量
};

//比赛阶段
struct stCenterMatchStage
{
	uint8 stageNumber;		//阶段序号
	uint8 stageMode;		//阶段比赛模式
	String stageRule;		//阶段详细规则
	uint32  init_score;			//初始分数
	float  init_score_scaling;	//初始分数缩放比例  决赛
	float  score_scaling;		//分数缩放比例  决赛
	uint32  base_score;			//初始底分
	uint32  eliminate;			//初始淘汰分数
	uint32  eliminateMode;			//初始淘汰分数
	uint8   stage_loop;			//每次游戏轮数   决赛
	uint32 limit_time;			//阶段总时间
	uint32 channel_limit_loop;			//阶段牌桌总局数
	std::vector<stEliminateIncrease > EliminateIncrease;  //淘汰积分增长
	std::vector<stEndCondition > EndConditionList;		//阶段结束条件
	stCenterMatchStage()
	{
		init();
	}
	void init() {
		limit_time = 0;
		channel_limit_loop = 0;
		stageNumber = 0;
		stageMode = 0;
		init_score = 0;
		base_score = 0;
		eliminate = 0;
		init_score_scaling = 0.0f;
		score_scaling = 0.0f;
		stage_loop = 0;
		EliminateIncrease.clear();
		EndConditionList.clear();
		eliminateMode = 0;
		stageRule = "";
	}
};

//比赛流程配置
struct stCenterMatchModeInfo
{
	uint32	game_id;			//游戏id
	uint32	agent_id;			//游戏id
	uint8	matchMode;			//比赛模式
	uint8   eachChannelPlayer;	//每桌游戏人数
	uint8	limit_match_num;	//最低匹配开始人数
	uint8	min_math_begin_channel;	//最低开赛桌
	uint8	min_math_begin_num;	//最低开赛人数
	uint32	no_channel_over_time;	//无比赛自动结束时间 分
	std::vector<stCenterMatchStage>  matchStage;//比赛阶段
	stCenterMatchModeInfo()
	{
		init();
	}
	void init()
	{
		game_id = 0;
		agent_id = 0;
		matchMode = 0;
		limit_match_num = 0;
		min_math_begin_channel = 0;
		min_math_begin_num = 0;
		no_channel_over_time = 0;
		matchStage.clear();
	}
};

struct stCommonActivity
{
	uint32 type;							// 活动类型(1 分享。。。）
	uint32 need_count;						// 需求次数
	uint32 finish_count;					// 可完成次数
	uint32 daily;							// 是否日常（0 否 1 是）
	
	uint32 begin_time;						// 开始时间
	uint32 end_time;						// 结束时间
	
	std::map<uint32, uint32> mapBounties;	// 奖励
	
	stCommonActivity()
	{
		Init();
	}
	
	void Init()
	{
		type = 0;
		need_count = 0;
		finish_count = 0;
		daily = 0;
		
		begin_time = 0;
		end_time =0;
		
		mapBounties.clear();
	}
	
};

struct stCommonSingleSignInfo
{
	uint32 week;								// 周几
	uint32 month;								// 月
	uint32 day;									// 日
	uint32 days;								// 天数（用于判断连签或者累签）
	
	String desc;								// 奖励描述
	std::map<uint32, uint32>	mapBounties;	// 奖励列表
	
	stCommonSingleSignInfo()
	{
		Init();
	}
	
	void Init()
	{
		week = 0;
		month = 0;
		day = 0;
		days = 0;
		
		desc = "";
		mapBounties.clear();
	}
};

struct stCommonSignInfo
{
	uint32 agent_id;			// 代理商ID
	uint32 gz_id;				// 分区ID
	uint32 sign_mode;			// 签到模式（1 周签到 2 月签到）
	uint32 sign_sub_mode;		// 签到子类型（1 固定签到奖励 2 连续签到奖励）
	uint32 update_combo_mode;	// 签到更新模式（1 周更新 2 月更新）
	uint32 update_bounty_mode;	// 奖励更新模式（1 周更新 2 月更新）
	
	String agent_name;		// 代理商名称
	
	std::vector<stCommonSingleSignInfo>	vSignInfo;		// 基础签到
	std::vector<stCommonSingleSignInfo>	vComboInfo;		// 连签信息
	std::vector<stCommonSingleSignInfo>	vCountInfo;		// 累签信息
	
	stCommonSignInfo()
	{
		Init();
	}
	
	void Init()
	{
		agent_id = 0;
		gz_id = 0;
		sign_mode = 0;
		sign_sub_mode = 0;
		update_combo_mode = 0;
		update_bounty_mode = 0;
		
		agent_name = "";
		vSignInfo.clear();
		vComboInfo.clear();
		vCountInfo.clear();
	}
};

struct stSignleEffortInfo
{
	uint32 model_id;		// 模式ID
	uint32 type;			// 类型
	uint32 gz_id;			// 分区ID
	uint32 data_gz_id;		// 数据存储分区ID
	uint32 need_count;		// 完成需要次数
	uint32 extra_data1;		// 附加判定数据1
	uint32 daily;			// 是否日常
	String name;			// 成就名称
	String content;			// 成就内容
	
	std::map<uint32, uint32> mapBounties;	// 奖励
	
	stSignleEffortInfo()
	{
		Init();
	}
	
	void Init()
	{
		model_id = 0;
		type = 0;
		gz_id = 0;
		data_gz_id = 0;
		need_count = 0;
		extra_data1 = 0;
		daily = 0;
		name = "";
		content = "";
		
		mapBounties.clear();
	}
};

struct stBuildEfforts
{
	uint32 agent_id;						// 代理商ID
	uint32 tt_effortid;						// 成就序列号
	uint32 daily;							// 每日更新（0 否 1 是）
	String agent_name;						// 代理商名称
	
	std::vector<uint32> effect_models;		// 要添加的成就列表
	std::vector<stSignleEffortInfo> vEfforts;	// 成就列表
	
	stBuildEfforts()
	{
		Init();
	}
	
	void Init()
	{
		agent_id = 0;
		tt_effortid = 0;
		daily = 0;
		agent_name = "";
		
		effect_models.clear();
		vEfforts.clear();
	}
};

struct stOrderScore
{
	uint32 start_order;
	uint32 end_order;
	
	float score;
	
	stOrderScore()
	{
		Init();
	}
	
	void Init()
	{
		start_order = 0;
		end_order = 0;
		
		score = 0.0f;
	}
};

struct stMatchOrderScore
{
	uint32 min_p;	// 最小人数
	uint32 max_p;	// 最大人数
	
	std::vector<stOrderScore> vOrderScore;
	
	stMatchOrderScore()
	{
		Init();
	}
	
	void Init()
	{
		min_p = 0;
		max_p = 0;
		
		vOrderScore.clear();
	}
};

// 斗地主机器人
struct stDDZRobot
{
	uint32 index;
	uint32 show_pid;
	uint32 show_uid;
	uint32 sex;
	uint32 char_id;
	
	String nick;
	String icon;
	String addr;
	
	uint32 init_coins;
	uint32 init_fangka;
	
	bool bUsed;
	
	stDDZRobot()
	{
		Init();
	}
	
	void Init()
	{
		index = 0;
		show_pid = 0;
		show_uid = 0;
		sex = 0;
		char_id = 0;
		
		nick = "";
		icon = "";
		addr = "";
		
		init_coins = 0;
		init_fangka = 0;
		
		bUsed = false;
	}
};

class TiXmlElement;
class WorldPacket;
class CharPtr;
struct Notice;
struct ItemData;
struct ItemSet;

#define WGS_XML_READ_WRITE_MUTEX_NAME      xml_read_write_shared_mutex
#define WGS_XML_READ_WRITE_MUTEX   mutable boost::shared_mutex WGS_XML_READ_WRITE_MUTEX_NAME;
#define WGS_XML_READ_LOCK             boost::shared_lock<boost::shared_mutex>  wgsXmlSharedMutexLock(WGS_XML_READ_WRITE_MUTEX_NAME);
#define WGS_XML_WRITE_LOCK 		boost::unique_lock<boost::shared_mutex>  wgsXmlWriteMutexLock(WGS_XML_READ_WRITE_MUTEX_NAME); 

#ifdef _USE_DEFAULT_XML_DATA_MGR_
	class XmlDataManager : public Singleton<XmlDataManager>
#else
	class XmlDataManager
#endif // _USE_DEFAULT_XML_DATA_MGR_
{
public:
	XmlDataManager();
	virtual ~XmlDataManager();
	// 获取升到指定等级的经验
	virtual const uint32 GetExpsOfLevel(const uint8 level) const;
	virtual const uint32 GetMaxLevel(void){ return m_mapLevelExp.size(); }
	// 获取配置信息
	virtual bool IsConfXmlValueExist(const String & str);
	virtual uint32 	GetConfXMLValue(const String & str);
	// 获取公共配置信息
	virtual uint32  GetCommXMLValue(const String & str);
	// 获取小游戏配置
	virtual uint32 	GetSMXMLValue(const String & str);
	// 获取财富称号
	virtual const uint8 GetWealthTitle(const uint32 coin) const;
	virtual const String* GetWealthTitleString(const uint32 & coin);
	virtual uint32 GetWealthTitleIndex(const uint32 &coins);
	virtual String GetWealthTitleByIndex(const uint32 &index);
	// 获取新手房间奖励包
	virtual inline const JackerooHortation & GetJackerooHortation() const {return m_jackerooHortation;}
	// 获取登录奖励
	virtual inline const std::map<uint32, LoginGift> & GetLoginGiftMap() const {return m_mapLoginGift;}
	// 获取登陆奖励数据
	virtual const LoginGift* GetLoginGift(const uint32 & day);
	// 获取登陆奖励MAP长度
	virtual uint32 GetLoginGiftMapSize(){ return m_mapLoginGift.size();}
	// 获取系统公告
	virtual inline const std::list<Notice> & GetSystemNotice() const {return m_lstNotices;}	
	// 获取黄钻等级奖励
	virtual const WebLvBounty*  GetWebLevelBounty(const uint32 & level);
	// 获取游戏分区ID的vector
	std::vector<uint32> GetGameIDVector();
	virtual inline std::map<String, GZIDInfo> GetGZIDInfo(){ return m_mapGzidInfo; }
	// 获取VIP房间铜钱限制
	virtual uint32 GetVipRoomBaseCoins(const uint32 base_coins);
	// 扑克框架获取公共配置
	virtual uint32 	GetPuKeXMLData(const uint32 & ai, const String & str);
	/**
	 * 获取物品集
	 *  @index 奖励脚本号
	 *  @iset 物品集对象
	 * 如果成功，返回true，否则false
	 */
	virtual bool GetItemSet(const uint32 index, ItemSet &iset);
public:
	// 初始化等级经验列表
	virtual bool InitLevelExpList();	
	// 发送协议
	// virtual void SendProtocol(WorldPacket &packet, const uint8 showType, const uint8 seat, std::vector<CharPtr> &vecChars);	
	/////////////////////////////////////////////////////
	//载入游戏配置文件
	virtual bool LoadGameConfig(void);
	virtual bool ReloadGameConfig(void);
	//载入游戏公共配置文件
	virtual bool LoadCommonConfig(void);
	virtual bool ReloadCommonConfig(void);
	// 载入小游戏配置文件
	virtual bool LoadSMGameConfig(void);
	virtual bool ReloadSMGameConfig(void);	
	// 加载财富称号
	virtual bool LoadWealthTitle();
	virtual bool ReloadWealthTitle();
	// 加载新手房间发钱礼包
	virtual bool LoadJackerooHortation();
	virtual bool ReloadJackerooHortation();
	// 加载登录礼包
	virtual bool LoadLoginGift();
	virtual bool ReloadLoginGift();
	// 加载系统公告
	virtual bool LoadSystemNotices();
	virtual bool ReloadSystemNotices();
	// 加载VIP房间铜钱配置
	virtual bool LoadViproomNeedcoins();
	virtual bool ReLoadViproomNeedcoins();
	// 加载腾讯用户黄钻奖励配置
	virtual bool LoadWebLevelConf(void);
	//加载任务配置
	virtual bool LoadMaJonMissionXml(void);
	virtual bool ReLoadMaJonMissionXml(void);
	virtual MaJonMission CreateMaJonMission(const uint32 mission_type,const uint8 offset_value = 0); 	//创建麻将任务
	// 加载机率配置
	virtual bool LoadChanceConf(void);
	virtual bool ReloadChanceConf(void);
	virtual const ChanceItem *GetChanceItem(void);
	virtual const ChanceItem *GetChanceItem(const uint32 & kind_id);
	virtual uint32 GetChanceList(const uint32 &kind_id, std::list<ChanceItem> & lstChance);
	// 加载分区名字
	virtual bool LoadGZIDName();
	// 获取分区ID
	virtual String GetGzIdName(const uint32 id);
	// 加载分区名字
	virtual bool ReloadGZIDName();
	// 加载服务器IP信息
	virtual bool LoadServerIP(void);
	// 重新加载服务器IP信息
	virtual bool ReloadServerIP(void);
	// 获取IP信息
	virtual const ServerIP* GetServerIP(const uint32 & gameid);
	// 邮件模板
	virtual bool LoadMailModel(void);
	virtual bool ReloadMailModel(void);
	virtual const MailModel * GetMailModel(const String & szKey);	
	//加载游戏分区ID配置
	virtual bool LoadGameIDXml();
	virtual bool ReLoadGameIDXml();
	//购买赠送小物品
	virtual bool LoadBuyLargessXml();
	virtual const BuyLargess *GetBuyLargess(const uint32 & buy_id);
	// 加载赠送打折卡配置
	virtual bool LoadGiveLeCardsXml();
	virtual bool ReLoadGiveLeCardsXml();	
	std::vector<LeCardGive> getGiveLeCardsInfo(const uint32 & reg_days);	
	// 加载水果机配置
	virtual void	LoadFruitXml(void);
	virtual void 	ReLoadFruitXml(void);	
	//得到水果机中奖项
	virtual FruitBounty GetFruitBounty(void);
	// 加载通用排行配置
	virtual bool 	LoadCommonOrderXml(void);
	virtual bool 	ReLoadCommonOrderXml(void);
	// 获得通用排行配置
	virtual std::map<uint32,stOrderInfo> GetCommonOrderMap(void);
	virtual stOrderInfo GetOrderValueKey(const uint32 & order_type);
	// 修改排行重置时间
	void SetCommonOrderResetTimer(const uint32 & order_id, const uint32 & timer);
	/**
	 * 加载物品集配置
	 */
	virtual bool LoadItemSetConfig();
	/********开心牧场*********/
	// 载入开心牧场
	virtual void LoadHappyFarm(void);
	// 获取牧场牲畜
	virtual const HappyFarm* GetHappyFarm(const uint32 &id);
	// 获取购买列表
	virtual uint32 GetHappyFarmList(std::map<uint32, HappyFarm> &mapHappyFarm);
	
	/************牌桌组局****************/
	// 加载游戏ID对应游戏名称配置
	virtual bool LoadGameNameXml(void);
	virtual bool ReLoadGameNameXml(void);
	
	std::vector<stGameModelName> GetGameIDName(){ return m_vGameIDNames; }
	std::map<uint32, String> GetGzIDName(){ return m_mapGzIDNames; }
	String GetGameNameByGameModelID(const uint32 & game_id, const uint32 & model_id);
	String GetGameNameByGzID(const uint32 & gz_id);
	
	// 加载组局游戏开局费配置
	virtual bool LoadCenterBattleOpenCoinsXml(void);
	virtual bool ReLoadCenterBattleOpenCoinsXml(void);
	
	stCenterBattleOpenCoins GetCenterBattleOpenCoins(const uint32 & agent_id, const uint32 & game_id, const uint32 & value, const uint8 & type, const uint8 & mode);
	stCenterBattleOpenCoins GetCenterBattleOpenCoins(const uint32 & agent_id, const uint32 & game_id, const uint32 & item_model, const uint32 & item_num, const uint32 & loop, const uint8 & mode);
	
	// 获得组局模式名称
	String GetCenterBattleGameModeName(const uint32 & agent_id, const uint32 & game_id, const uint8 & mode);
	std::map<uint32, std::vector<stCenterBattleOpenCoins> > GetOpenCoinsTotalInfo(const uint32 & agent_id);
	// 判断某个玩法是否支持某个平台
	bool IsPfInCenterBattleMode(const uint32 & agent_id, const uint32 & game_id, const uint32 & value, const uint8 & mode, String strPf);
	
		// 获得某个游戏的观战标志
	uint32 GetGameWatchMode(const uint32 & agent_id, const uint32 & game_id, const uint32 & item_model, const uint32 & mode, const uint32 & loop);
	
	
	// 加载游戏ID配置
	virtual bool LoadGameIdsXml(void);
	virtual bool ReLoadGameIdsXml(void);
	// 检测游戏ID是否存在配置中
	bool IsInGameIds(const uint32 & game_id);
	
	// 加载棋牌圈模式对应城市ID和AI配置
	virtual bool LoadCenterBattleModeXml(void);
	virtual bool ReLoadCenterBattleModeXml(void);
	// 获取棋牌圈游戏模式对应AI配置
	stCenterBattleMode GetCenterBattleModeByGameid(const uint32 & game_id, const uint8 & mode);
	// AI号是否属于棋牌圈
	bool IsAIInCenterBattle(const uint32 & game_id, const uint32 & ai);
	
	// 加载评价标签ID配置
	virtual bool LoadCenterJudgeLabelIDXml(void);
	virtual bool ReLoadCenterJudgeLabelIDXml(void);
	
	// 判断评价标签ID是否存在
	bool IsJudgeLabelIDExist(const uint32 & label_id);
	// 获得标签名称
	String GetJudgeLabelNameByID(const uint32 & label_id);
	// 获得评价标签列表
	std::map<uint32, String> GetJudgeLabelIDMap(){ return m_mapJudgeLabelID; }
	
	// 加载打包商品配置
	virtual bool LoadBuyUnionGoodsXml(void);
	virtual bool ReloadBuyUnionGoodsXml(void);
	
	// 获得打包礼品配置
	stBuyUnionGoods GetUnionGoodsByID(const uint32 & goods_id);
	
	// 加载公共在线奖励配置
	virtual bool LoadCommonOnlineGiftXml(void);
	virtual bool ReLoadCommonOnlineGiftXml(void);
	
	// 获取在线奖励配置列表
	stCommonOnlineGift GetCommonOnlineGift(){ return m_stCommonGift; }
	
	// 加载网关原因配置
	virtual bool LoadGatewayResonXml(void);
	virtual bool ReLoadGatewayResonXml(void);
	
	// 获得网关原因内容
	String GetGatewayReson(const uint32 & reson_id);
	
	// 加载代理商道具名称
	virtual bool LoadItemModelNameXml(void);
	virtual bool ReLoadItemModelNameXml(void);
	
	String GetItemModelNameByAgentID(const uint32 & agent_id, const uint32 & item_modelid);
	
	// 加载注册赠送道具数量
	virtual bool LoadRegisterGiveItemsXml(void);
	virtual bool ReLoadRegisterGiveItemsXml(void);
	
	std::map<uint32, uint32> GetRegisterGiveItems(const uint32 & agent_id);
	
	//---------------------棋牌圈比赛--------------------------------
	virtual bool LoadCenterMatchModeInfo(void);
	virtual bool ReLoadCenterMatchModeInfo(void);
	stCenterMatchModeInfo GetCenterMatchModeInfo(const uint32 &  agent_id, const uint8 & mode_id);
	
	//----------------------公共活动---------------------------------
	// 活动相关
	virtual bool LoadCommonActivity(void);
	virtual bool ReLoadCommonActivity(void);
	stCommonActivity GetCommonActivity(const uint32 &  agent_id, const uint32 & type);
	
	// 签到相关
	virtual bool LoadCommonSignInfoXml(void);
	virtual bool ReLoadCommonSignInfoXml(void);
	stCommonSignInfo GetCommonSignInfo(const uint32 & agent_id, const uint32 & gz_id);
	
	// 创建成就相关
	virtual bool LoadBuildEffortsXml(void);
	virtual bool ReLoadBuildEffortsXml(void);
	stBuildEfforts GetBuildEfforts(const uint32 & agent_id);
	std::vector<stSignleEffortInfo> GetBuildEffortsStructVector(const uint32 & agent_id);
	
	// 网关域名相关
	virtual bool LoadGatewayHttpHoseAddr(void);
	virtual bool ReLoadGatewayHttpHoseAddr(void);
	
	String GetGatewayHttpHostAddr(const uint32 & agent_id);
	
	// 扑克框架数据配置
	virtual bool LoadPuKePublicDataXml(void);
	virtual bool ReLoadPuKePublicDataXml(void);
	
	// 比赛积分配置
	virtual bool LoadMatchOrderScoreXml(void);
	virtual bool ReLoadMatchOrderScoreXml(void);
	
	// 获取比赛排名对应积分
	virtual float GetMatchOrderScore(const uint32 & total_player, const uint32 & order);
	
	// 加载机器人配置
	bool LoadDDZRobotXml();
	bool ReLoadDDZRobotXml();
	
	
	// 获得机器人配置列表
	std::vector<stDDZRobot> GetDDZRobotVector(){ return m_vDDZRobot; }
	// 获取下注配置
	std::vector<uint32> GetBankerDDZChipinVector(const uint32 & init_score, const uint32 & score);
	// 修改机器人角色ID
	void SetRobotData(const uint32 & index, const uint32 & char_id, const uint32 & show_pid, const String & strAddr);
	// 判断玩家是否在控制列表中
	bool IsBankerInContrlList(const uint32 & char_id);
	// 获得一个随机机器人ID
	uint32 getBankerInContrlCharIdRandom();
	// 设置机器人使用状态
	void setRobotUsed(const uint32 & char_id, bool bUsed);
	// 获得一个机器人被使用状态
	bool isRobotUsed(const uint32 & char_id);
	// 获得一个机器人的PID
	uint32 getRobotShowPid(const uint32 & char_id);
	// 给机器人随机昵称
	String randomRobotNick();
	// 给机器人随机头像
	String randomRobotIcon();
	// 给机器人随机显示用的PID
	uint32 randomRobotPid();
	// 给机器人随机地址
	String randomRobotAddr();
	// 设置机器人昵称头像
	bool setDDZRobotNickIcon(const uint32 & index, String strNewName, String strNewIcon);
	// 机器人根据charid排序
	void OrderRobotByCharid();
	// 重置所有机器人昵称头像
	void ResetDDZRobotNickIcon();
	
protected:
	WGS_XML_READ_WRITE_MUTEX
	/**
	 * 从map列表获取一个节点
	 *  @key 列表脚本号
	 */
	TiXmlElement* GetItemSetNode(const String &key);
	/**
	 * 从列表获取一条物品数据
	 *  @index 列表脚本号
	 *  @idata 物品数据
	 * 如果成功，返回true，否则false
	 */
	virtual bool GetDataFromList(const uint32 index, ItemData &idata);
private:
	// 等级，经验
	std::map<uint8, uint32> m_mapLevelExp;
	// 游戏配置XML
	std::map<String, uint32> m_mapGameConfig;
	// 公共配置XML
	std::map<String, uint32> m_mapCommConfig;
	// 小游戏配置XML
	std::map<String, uint32> m_mapSMGameConfig;
	// 财富称号
	std::map<uint8, WealthTitle> m_mapWealthTitle;
	// 新手房间奖励
	JackerooHortation m_jackerooHortation;
	// 连续登录奖励
	std::map<uint32, LoginGift> m_mapLoginGift;
	// 系统公告
	std::list<Notice> m_lstNotices;
	// 平台等级奖励
	std::map<uint32, WebLvBounty> m_mapWebLvBounty;	
	// 特殊用户列表
	std::list<uint32> m_listVIPUsers;
	// 轮盘赌物品列表
	std::list<ChanceList> m_listChances;
	// 分区名字
	std::map<uint32, String> m_mapGZIDName;	
	// 服务器IP列表
	std::list<ServerIP>	m_lstServerIP;
	// 邮件模板列表
	std::map<String, MailModel> m_mapMailModel;
	// VIP房间铜钱配置
	std::map<uint32,uint32> m_mapVipRoomCoins;
	// 麻将任务配置
	std::map<uint32,std::vector<MaJonMission> > m_majonMissions;
	// GZID配置信息
	std::map<String, GZIDInfo> m_mapGzidInfo;
	// 购买赠送小物品
	std::list<BuyLargess> m_lstBuyLargess;
	// 赠送打折卡列表
	std::list<LeCardGive> m_lstLeCardsGive;
	// 水果机几率配置列表
	std::list<FruitBounty> m_vFruitsBounty;
	// 物品集列表
	std::map<String, TiXmlElement>	m_mapItemSetNode;
	// 开心牧场牲畜
	std::map<uint32, HappyFarm> m_mapHappyFarms;
	// 排行配置列表
	std::map<uint32, stOrderInfo> m_mapCommonOrder;
	// 游戏ID以及游戏分区ID对应游戏名称配置
	std::vector<stGameModelName> m_vGameIDNames;
	std::map<uint32, String> m_mapGzIDNames;
	// 开局费用配置
	std::map< uint32, std::map<uint32, std::vector<stCenterBattleOpenCoins> > > m_mapCenterBattleOpenCoins;
	// 游戏服务器自己对应游戏ID
	std::vector<uint32> m_vGameIDs;
	// 棋牌圈模式对应城市ID和AI号
	std::map<uint32, std::vector<stCenterBattleMode> > m_mapCenterBattleMode;
	// 评价ID配置
	std::map<uint32, String> m_mapJudgeLabelID;
	// 打包物品出售配置
	std::map<uint32, stBuyUnionGoods> m_mapUnionGoods;
	// 通用在线奖励配置
	stCommonOnlineGift m_stCommonGift;
	
	// 网关调用结果原因
	std::map<uint32, String> m_mapGatewayReson;
	
	// 代理商道具名称
	std::map<uint32, std::map<uint32, String> > m_mapItemModelName;
	
	// 注册赠送道具
	std::map<uint32, std::map<uint32, uint32> > m_mapRegisterGiveItems;

	//棋牌圈比赛模式信息
	std::map<uint32, std::vector<stCenterMatchModeInfo > > CenterMatchModeInfoMap;
	
	// 公共活动列表
	std::map<uint32, std::vector<stCommonActivity> > m_mapCommonActivity;
	
	// 公共签到信息
	std::vector<stCommonSignInfo> m_vCommonSign;
	
	// 代理商成就配置
	std::map<uint32, stBuildEfforts> m_mapBuildEfforts;
	
	// 代理商域名首地主配置
	std::map<uint32, String> m_mapGatewayHttpHostAddr;
	
	// 比赛积分列表
	std::vector<stMatchOrderScore> m_vMarchOrderScore;
	
	//扑克框架配置列表
	std::map<uint32, std::map<String, uint32 > > m_mapPuKeMoreData;
	
	// 机器人列表
	std::vector<stDDZRobot> m_vDDZRobot;
	std::vector<String> m_vDDZRobotName;
	std::vector<String> m_vDDZRobotIcon;
	std::vector<uint32> m_vDDZRobotPid;
	std::vector<String> m_vDDZRobotAddr;
};

// #define sXmlDataMgr XmlDataManager::getSingleton()

#endif // _USE_DEFAULT_XML_DATA_MGR_
